package qc.module.ehs.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import qc.common.core.enums.EhsHazardIndentificationResultTypeEnum;
import qc.common.core.enums.EhsRiskLevelEnum;
import qc.common.core.enums.ResourceStatusFlagEnum;
import qc.common.core.exception.QCPromptException;
import qc.common.core.unify.QCUnifyReturnValue;
import qc.common.core.utils.IdentifierUtil;
import qc.module.ehs.dto.hazard.EhsHazardInfoDto;
import qc.module.ehs.dto.respinsibility.UnitResponsibilitySetDto;
import qc.module.ehs.dto.unit.*;
import qc.module.ehs.entity.EhsOrg;
import qc.module.ehs.entity.EhsTplUnitcategory;
import qc.module.ehs.entity.EhsUnitInfo;
import qc.module.ehs.entity.EhsUnitStaticinfo;
import qc.module.ehs.mapper.EhsUnitInfoMapper;
import qc.module.ehs.repository.EhsOrgRepository;
import qc.module.ehs.repository.EhsTplUnitcategoryRepository;
import qc.module.ehs.repository.EhsUnitInfoRepository;
import qc.module.ehs.repository.EhsUnitStaticInfoRepository;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * 单元划分基础信息接口Service
 *
 * @author QuCheng Tech
 * @create 2024/5/22
 */
@Service
public class EhsUnitInfoService {

    private EhsUnitInfoRepository repository;

    @Autowired
    public void setRepository(EhsUnitInfoRepository repository) {
        this.repository = repository;
    }

    @Autowired
    private EhsOrgRepository orgRepository;

    @Autowired
    private EhsTplUnitcategoryRepository unitcategoryRepository;

    @Autowired
    private EhsUnitStaticInfoRepository unitStaticInfoRepository;

    @Autowired
    private EhsHazardInfoService hazardInfoService;

    /**
     * 查询单元信息，以TreeTable树型形式返回数据；查询条件中的“是否根据用户部门进行过滤”控制时返回所有单元还是根据用户所在部门返回作为责任部门的单元；
     *
     * @param condition 查询条件
     * @param deptIds   当前用户关联的部门ID集合，如果查询条件中的“是否根据用户部门进行过滤”为true需要根据用户所在部门集合进行过滤只显示用户所在部门作为责任部门的单元；
     * @return List<EhsUnitTreeTableItemDto>
     * @author QuCheng Tech
     * @since 2024/5/30
     */
    public List<EhsUnitTreeTableItemDto> queryTreeTable(EhsUnitQueryConditionDto condition, List<Integer> deptIds) throws QCPromptException {
        //1.查询条件判断
        if (condition == null)
            throw new QCPromptException("查询条件不能为空");
        if (StringUtils.isBlank(condition.getOrgcode()))
            throw new QCPromptException("组织代码不能为空");

        //2.查询指定条件的单元信息，如果查询指定单元（该单元作为一级单元，返回子级）,否则查询所有
        List<EhsUnitInfo> ens = new ArrayList<>();
        LambdaQueryWrapper<EhsUnitInfo> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(EhsUnitInfo::getOrgcode, condition.getOrgcode());
        //查询指定单元
        if (StringUtils.isNotBlank(condition.getParentid())) {
            wrapper.eq(EhsUnitInfo::getUnitid, condition.getParentid());
            EhsUnitInfo unitInfo = repository.selectOne(wrapper);
            ens.add(unitInfo);
            //查询单元的子级单元
            LambdaQueryWrapper<EhsUnitInfo> subUnitWrapper = new LambdaQueryWrapper<>();
            subUnitWrapper.ne(EhsUnitInfo::getUnitid, unitInfo.getUnitid())
                    .likeRight(EhsUnitInfo::getLevelcode, unitInfo.getLevelcode());//根据单元的层级编码开头去查询子级
            List<EhsUnitInfo> subUniInfos = repository.selectList(subUnitWrapper);
            if (CollectionUtils.isNotEmpty(subUniInfos)) ens.addAll(subUniInfos);
        } else {
            wrapper.orderByAsc(EhsUnitInfo::getOdr, EhsUnitInfo::getUnitname);
            ens = repository.selectList(wrapper);
        }
        if (CollectionUtils.isEmpty(ens)) return null;

        //3.ens转换为TreeTableItemDto
        List<EhsUnitTreeTableItemDto> dtos = EhsUnitInfoMapper.MAPPER.toTreeTableItemDtoList(ens);

        //4.将查询结果构建为树型结构
        List<EhsUnitTreeTableItemDto> result = new ArrayList<>();
        //获取根节点集合（如果查询指定单元，将指定单元作为根层级单元，否则parentid为空的作为根层级单元）
        List<EhsUnitTreeTableItemDto> rootUnits = new ArrayList<>();
        if (StringUtils.isNotBlank(condition.getParentid())) {
            rootUnits = dtos.stream().
                    filter(p -> p.getUnitid().equals(condition.getParentid())).collect(Collectors.toList());
        } else {
            rootUnits = dtos.stream().
                    filter(p -> StringUtils.isEmpty(p.getParentid())).collect(Collectors.toList());
        }
        //构建树型结构，设置根单元的子节点单元
        if (CollectionUtils.isNotEmpty(rootUnits))
            result = getSubUnits(dtos, rootUnits);

        //5.从result中筛选符合查询条件的结果
        Iterator<EhsUnitTreeTableItemDto> rootLevelIterator = result.iterator();
        while (rootLevelIterator.hasNext()) {
            EhsUnitTreeTableItemDto rootlevel = rootLevelIterator.next();

            if (rootlevel.getChildren() != null && rootlevel.getChildren().size() > 0x0) {
                //子级结果筛选
                filterSubTreeTableResult(rootlevel, condition, deptIds);
            }

            //是否移除
            boolean isRemoveRootLevel = false;
            ////上级单元编码不为空的情况，匹配了再判断是否包含子级
            //if (StringUtils.isNotBlank(condition.getParentid())){
            //    if (rootlevel.getParentid().equals(condition.getParentid())){
            //        //匹配，判断是否包含子级，不包含则设置子级为空
            //        if (!condition.getIncludechilds()) rootlevel.setChildren(null);
            //    }else{
            //        //第一次层级不匹配，移除
            //        isRemoveRootLevel = true;
            //    }
            //}else{
            //    //如果上级单元编码为空，判断是否包含子级
            //    if (!condition.getIncludechilds()) rootlevel.setChildren(null);
            //}
            //判断是否包含子级，不包含则设置子级为空
            if (condition.isIncludechilds() == false) rootlevel.setChildren(null);

            if (rootlevel.getChildren() == null || rootlevel.getChildren().size() == 0x0) {
                //是否为在建工程：为0表示false，为1表示true，为空或其他时表示不管该标记状态
                if (StringUtils.isNotBlank(condition.getIsconstruction())) {
                    if (condition.getIsconstruction().equals("0")) {
                        if (rootlevel.isIsconstruction() == true) isRemoveRootLevel = true;
                    } else if (condition.getIsconstruction().equals("1")) {
                        if (rootlevel.isIsconstruction() == false) isRemoveRootLevel = true;
                    }
                }
                //是否根据用户部门进行过滤:为true表示根据当前用户所关联部门对单元进行筛选过滤，为false表示不过滤
                if (isRemoveRootLevel == false && condition.isIsdept() == true) {
                    if (CollectionUtils.isNotEmpty(deptIds)) {
                        boolean deptIsExist = false;//level4的部门是否匹配用户部门
                        for (Integer deptId : deptIds) {
                            if (deptId == rootlevel.getResdeptid()) {
                                deptIsExist = true;
                            }
                        }
                        if (!deptIsExist) isRemoveRootLevel = true;
                    }
                }
                //关键子匹配
                if (isRemoveRootLevel == false && StringUtils.isNotBlank(condition.getKeywords())) {
                    if (!(rootlevel.getUnitid().contains(condition.getKeywords())) &&
                            !(rootlevel.getUnitname().contains(condition.getKeywords()))
                    ) {
                        isRemoveRootLevel = true;
                    }
                }
                //是否只返回状态正常的记录
                if (isRemoveRootLevel == false && condition.isFlagisvalid() == true) {
                    if (rootlevel.getFlag() != ResourceStatusFlagEnum.NORMAL.getIndex()) isRemoveRootLevel = true;
                }

                if (isRemoveRootLevel) rootLevelIterator.remove();
            }

        }

        //6.返回结果
        return result;
    }

    /**
     * 递归获取子级单元信息
     *
     * @param dtos        所有单元信息
     * @param parentUnits 父级单元信息
     * @return List<EhsUnitTreeTableItemDto>
     * @author QuCheng Tech
     * @since 2024/5/23
     */
    private List<EhsUnitTreeTableItemDto> getSubUnits(List<EhsUnitTreeTableItemDto> dtos, List<EhsUnitTreeTableItemDto> parentUnits) {
        List<EhsUnitTreeTableItemDto> result = new ArrayList<>();

        if (CollectionUtils.isEmpty(dtos)) return null;

        if (CollectionUtils.isNotEmpty(parentUnits)) {
            for (EhsUnitTreeTableItemDto pUnit : parentUnits) {
                //获取子级单元信息集合
                List<EhsUnitTreeTableItemDto> subUnits = dtos.stream().filter(p -> pUnit.getUnitid().equals(p.getParentid())).collect(Collectors.toList());
                if (CollectionUtils.isNotEmpty(subUnits)) {
                    getSubUnits(dtos, subUnits);
                    pUnit.setChildren(subUnits);
                }
                result.add(pUnit);
            }
        }
        return result;
    }

    /**
     * 递归过滤单元TreeTable的子级结果
     *
     * @param rootLevel 父层级单元
     * @param condition 过滤条件
     * @param deptIds   当前用户所属部门集合
     * @author QuCheng Tech
     * @since 2024/5/30
     */
    private void filterSubTreeTableResult(EhsUnitTreeTableItemDto rootLevel, EhsUnitQueryConditionDto condition, List<Integer> deptIds) {
        Iterator<EhsUnitTreeTableItemDto> subLevelIterator = rootLevel.getChildren().iterator();
        while (subLevelIterator.hasNext()) {
            EhsUnitTreeTableItemDto subLevel = subLevelIterator.next();

            if (subLevel.getChildren() != null && subLevel.getChildren().size() > 0x0) {
                filterSubTreeTableResult(subLevel, condition, deptIds);
            }

            //上级单元编码不为空的情况，匹配了再判断是否包含子级
            //if (StringUtils.isNotBlank(condition.getParentid())){
            //    if (subLevel.getParentid().equals(condition.getParentid())){
            //        //匹配，判断是否包含子级，不包含则设置子级为空
            //        if (!condition.getIncludechilds()) subLevel.setChildren(null);
            //    }
            //}else{
            //    //如果上级单元编码为空，判断是否包含子级
            //    if (!condition.getIncludechilds()) subLevel.setChildren(null);
            //}
            //判断是否包含子级，不包含则设置子级为空
            if (condition.isIncludechilds() == false) subLevel.setChildren(null);

            if (subLevel.getChildren() == null || subLevel.getChildren().size() == 0x0) {
                //是否移除
                boolean isRemoveSubLevel = false;
                //是否为在建工程：为0表示false，为1表示true，为空或其他时表示不管该标记状态
                if (StringUtils.isNotBlank(condition.getIsconstruction())) {
                    if (condition.getIsconstruction().equals("0")) {
                        if (subLevel.isIsconstruction() == true) isRemoveSubLevel = true;
                    } else if (condition.getIsconstruction().equals("1")) {
                        if (subLevel.isIsconstruction() == false) isRemoveSubLevel = true;
                    }
                }
                //是否根据用户部门进行过滤:为true表示根据当前用户所关联部门对单元进行筛选过滤，为false表示不过滤
                if (condition.isIsdept() == true) {
                    if (CollectionUtils.isNotEmpty(deptIds)) {
                        boolean deptIsExist = false;//level4的部门是否匹配用户部门
                        for (Integer deptId : deptIds) {
                            if (deptId == subLevel.getResdeptid()) {
                                deptIsExist = true;
                            }
                        }
                        if (!deptIsExist) isRemoveSubLevel = true;
                    }
                }
                //关键子匹配
                if (StringUtils.isNotBlank(condition.getKeywords())) {
                    if (!(subLevel.getUnitid().contains(condition.getKeywords())) &&
                            !(subLevel.getUnitname().contains(condition.getKeywords()))
                    ) {
                        isRemoveSubLevel = true;
                    }
                }
                //是否只返回状态正常的记录
                if (condition.isFlagisvalid() == true) {
                    if (subLevel.getFlag() != ResourceStatusFlagEnum.NORMAL.getIndex()) isRemoveSubLevel = true;
                }
                if (isRemoveSubLevel) subLevelIterator.remove();
            }

        }
    }

    /**
     * 查询单元简要信息
     * 用于在其他模块（如危险源台账）作为查询条件或表单选择数据接口使用；以层级形式返回单元列表（可以根据条件根据用户部门筛选）
     *
     * @param condition 查询条件
     * @return List<EhsUnitTreeSimpleDto>
     * @throws QCPromptException
     * @author QuCheng Tech
     * @since 2024/5/31
     */
    public List<EhsUnitTreeSimpleDto> queryTreeSimple(EhsUnitQueryConditionDto condition, List<Integer> deptIds) throws QCPromptException {
        //1.查询条件判断
        if (condition == null)
            throw new QCPromptException("查询条件不能为空");
        if (StringUtils.isBlank(condition.getOrgcode()))
            throw new QCPromptException("组织代码不能为空");

        //2.查询指定条件的单元信息，如果查询指定单元（该单元作为一级单元，返回子级）,否则查询所有
        List<EhsUnitInfo> ens = new ArrayList<>();
        LambdaQueryWrapper<EhsUnitInfo> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(EhsUnitInfo::getOrgcode, condition.getOrgcode());
        //查询指定单元
        if (StringUtils.isNotBlank(condition.getParentid())) {
            wrapper.eq(EhsUnitInfo::getUnitid, condition.getParentid());
            EhsUnitInfo unitInfo = repository.selectOne(wrapper);
            ens.add(unitInfo);
            //查询单元的子级单元
            LambdaQueryWrapper<EhsUnitInfo> subUnitWrapper = new LambdaQueryWrapper<>();
            subUnitWrapper.ne(EhsUnitInfo::getUnitid, unitInfo.getUnitid())
                    .likeRight(EhsUnitInfo::getLevelcode, unitInfo.getLevelcode());//根据单元的层级编码开头去查询子级
            List<EhsUnitInfo> subUniInfos = repository.selectList(subUnitWrapper);
            if (CollectionUtils.isNotEmpty(subUniInfos)) ens.addAll(subUniInfos);
        } else {
            wrapper.orderByAsc(EhsUnitInfo::getOdr, EhsUnitInfo::getUnitname);
            ens = repository.selectList(wrapper);
        }
        if (CollectionUtils.isEmpty(ens)) return null;

        //3.转换为dtoSimpleList
        List<EhsUnitSimpleDto> dtos = EhsUnitInfoMapper.MAPPER.toDtoSimpleList(ens);

        List<EhsUnitTreeSimpleDto> result = new ArrayList<>();

        //4.将查询结果构建为树型结构
        //获取根节点集合（如果查询指定单元，将指定单元作为根层级单元，否则parentid为空的作为根层级单元）
        List<EhsUnitSimpleDto> rootUnits = new ArrayList<>();
        if (StringUtils.isNotBlank(condition.getParentid())) {
            rootUnits = dtos.stream().
                    filter(p -> p.getUnitid().equals(condition.getParentid())).collect(Collectors.toList());
        } else {
            rootUnits = dtos.stream().
                    filter(p -> StringUtils.isEmpty(p.getParentid())).collect(Collectors.toList());
        }
        if (CollectionUtils.isNotEmpty(rootUnits)) {
            for (EhsUnitSimpleDto rootUnit : rootUnits) {
                EhsUnitTreeSimpleDto unitTreeSimpleDto = new EhsUnitTreeSimpleDto();
                List<EhsUnitTreeSimpleDto> children = new ArrayList<>();
                unitTreeSimpleDto.setInfo(rootUnit);
                unitTreeSimpleDto.setChildren(children);
                getSubUnitsSimple(dtos, rootUnit, children);
                result.add(unitTreeSimpleDto);
            }
        }

        //5.从result中筛选符合查询条件的结果
        Iterator<EhsUnitTreeSimpleDto> rootLevelIterator = result.iterator();
        while (rootLevelIterator.hasNext()) {
            EhsUnitTreeSimpleDto rootlevel = rootLevelIterator.next();

            if (rootlevel.getChildren() != null && rootlevel.getChildren().size() > 0x0) {
                //子级结果筛选
                filterSubTreeSimpleResult(rootlevel, condition, deptIds);
            }

            //是否移除
            boolean isRemoveRootLevel = false;
            ////上级单元编码不为空的情况，匹配了再判断是否包含子级
            //if (StringUtils.isNotBlank(condition.getParentid())){
            //    if (rootlevel.getInfo().getParentid().equals(condition.getParentid())){
            //        //匹配，判断是否包含子级，不包含则设置子级为空
            //        if (!condition.getIncludechilds()) rootlevel.setChildren(null);
            //    }else{
            //        //第一次层级不匹配，移除
            //        isRemoveRootLevel = true;
            //    }
            //}else{
            //    //如果上级单元编码为空，判断是否包含子级
            //    if (!condition.getIncludechilds()) rootlevel.setChildren(null);
            //}
            //判断是否包含子级，不包含则设置子级为空
            if (condition.isIncludechilds() == false) rootlevel.setChildren(null);

            if (rootlevel.getChildren() == null || rootlevel.getChildren().size() == 0x0) {
                //是否为在建工程：为0表示false，为1表示true，为空或其他时表示不管该标记状态
                if (StringUtils.isNotBlank(condition.getIsconstruction())) {
                    if (condition.getIsconstruction().equals("0")) {
                        if (rootlevel.getInfo().isIsconstruction() == true) isRemoveRootLevel = true;
                    } else if (condition.getIsconstruction().equals("1")) {
                        if (rootlevel.getInfo().isIsconstruction() == false) isRemoveRootLevel = true;
                    }
                }
                //是否根据用户部门进行过滤:为true表示根据当前用户所关联部门对单元进行筛选过滤，为false表示不过滤
                if (isRemoveRootLevel == false && condition.isIsdept() == true) {
                    if (CollectionUtils.isNotEmpty(deptIds)) {
                        boolean deptIsExist = false;//level4的部门是否匹配用户部门
                        for (Integer deptId : deptIds) {
                            if (deptId == rootlevel.getInfo().getResdeptid()) {
                                deptIsExist = true;
                            }
                        }
                        if (!deptIsExist) isRemoveRootLevel = true;
                    }
                }
                //关键子匹配
                if (isRemoveRootLevel == false && StringUtils.isNotBlank(condition.getKeywords())) {
                    if (!(rootlevel.getInfo().getUnitid().contains(condition.getKeywords())) &&
                            !(rootlevel.getInfo().getUnitname().contains(condition.getKeywords()))
                    ) {
                        isRemoveRootLevel = true;
                    }
                }
                //是否只返回状态正常的记录
                if (isRemoveRootLevel == false && condition.isFlagisvalid() == true) {
                    if (rootlevel.getInfo().getFlag() != ResourceStatusFlagEnum.NORMAL.getIndex())
                        isRemoveRootLevel = true;
                }

                if (isRemoveRootLevel) rootLevelIterator.remove();
            }

        }

        return result;
    }

    /**
     * 拼接父级单元的子孙层级结构
     *
     * @param dtos         所有单元信息
     * @param parentUnit   父级单元
     * @param parentChilds 父级单元的子孙集合
     * @author QuCheng Tech
     * @since 2024/5/31
     */
    public void getSubUnitsSimple(List<EhsUnitSimpleDto> dtos, EhsUnitSimpleDto parentUnit, List<EhsUnitTreeSimpleDto> parentChilds) {
        List<EhsUnitSimpleDto> subUnits = dtos.stream().filter(p -> p.getParentid() != null &&
                p.getParentid().equals(parentUnit.getUnitid())).collect(Collectors.toList());
        for (EhsUnitSimpleDto subUnit : subUnits) {
            EhsUnitTreeSimpleDto unitTreeSimpleDto = new EhsUnitTreeSimpleDto();
            List<EhsUnitTreeSimpleDto> children = new ArrayList<>();
            unitTreeSimpleDto.setInfo(subUnit);
            unitTreeSimpleDto.setChildren(children);

            parentChilds.add(unitTreeSimpleDto);

            getSubUnitsSimple(dtos, subUnit, children);
        }
    }

    /**
     * 递归过滤单元TreeSimple的子级结果
     *
     * @param rootLevel 父层级单元
     * @param condition 过滤条件
     * @param deptIds   当前用户所属部门集合
     * @author QuCheng Tech
     * @since 2024/5/31
     */
    private void filterSubTreeSimpleResult(EhsUnitTreeSimpleDto rootLevel, EhsUnitQueryConditionDto condition, List<Integer> deptIds) {
        Iterator<EhsUnitTreeSimpleDto> subLevelIterator = rootLevel.getChildren().iterator();
        while (subLevelIterator.hasNext()) {
            EhsUnitTreeSimpleDto subLevel = subLevelIterator.next();

            if (subLevel.getChildren() != null && subLevel.getChildren().size() > 0x0) {
                filterSubTreeSimpleResult(subLevel, condition, deptIds);
            }

            ////上级单元编码不为空的情况，匹配了再判断是否包含子级
            //if (StringUtils.isNotBlank(condition.getParentid())){
            //    if (subLevel.getInfo().getParentid().equals(condition.getParentid())){
            //        //匹配，判断是否包含子级，不包含则设置子级为空
            //        if (!condition.getIncludechilds()) subLevel.setChildren(null);
            //    }
            //}else{
            //    //如果上级单元编码为空，判断是否包含子级
            //    if (!condition.getIncludechilds()) subLevel.setChildren(null);
            //}
            //判断是否包含子级，不包含则设置子级为空
            if (condition.isIncludechilds() == false) subLevel.setChildren(null);

            if (subLevel.getChildren() == null || subLevel.getChildren().size() == 0x0) {
                //是否移除
                boolean isRemoveSubLevel = false;
                //是否为在建工程：为0表示false，为1表示true，为空或其他时表示不管该标记状态
                if (StringUtils.isNotBlank(condition.getIsconstruction())) {
                    if (condition.getIsconstruction().equals("0")) {
                        if (subLevel.getInfo().isIsconstruction() == true) isRemoveSubLevel = true;
                    } else if (condition.getIsconstruction().equals("1")) {
                        if (subLevel.getInfo().isIsconstruction() == false) isRemoveSubLevel = true;
                    }
                }
                //是否根据用户部门进行过滤:为true表示根据当前用户所关联部门对单元进行筛选过滤，为false表示不过滤
                if (condition.isIsdept() == true) {
                    if (CollectionUtils.isNotEmpty(deptIds)) {
                        boolean deptIsExist = false;//level4的部门是否匹配用户部门
                        for (Integer deptId : deptIds) {
                            if (deptId == subLevel.getInfo().getResdeptid()) {
                                deptIsExist = true;
                            }
                        }
                        if (!deptIsExist) isRemoveSubLevel = true;
                    }
                }
                //关键子匹配
                if (StringUtils.isNotBlank(condition.getKeywords())) {
                    if (!(subLevel.getInfo().getUnitid().contains(condition.getKeywords())) &&
                            !(subLevel.getInfo().getUnitname().contains(condition.getKeywords()))
                    ) {
                        isRemoveSubLevel = true;
                    }
                }
                //是否只返回状态正常的记录
                if (condition.isFlagisvalid() == true) {
                    if (subLevel.getInfo().getFlag() != ResourceStatusFlagEnum.NORMAL.getIndex())
                        isRemoveSubLevel = true;
                }
                if (isRemoveSubLevel) subLevelIterator.remove();
            }

        }
    }

    /**
     * 查询单元信息，以List形式返回数据；查询条件中的“是否根据用户部门进行过滤”控制时返回所有单元还是根据用户所在部门返回作为责任部门的单元；
     *
     * @param condition 查询条件
     * @param deptIds   当前用户关联的部门ID集合，如果查询条件中的“是否根据用户部门进行过滤”为true需要根据用户所在部门集合进行过滤只显示用户所在部门作为责任部门的单元；
     * @return List<EhsUnitTreeTableItemDto>
     * @author QuCheng Tech
     * @since 2024/5/23
     */
    public List<EhsUnitDto> queryList(EhsUnitQueryConditionDto condition, List<Integer> deptIds) throws QCPromptException {
        //1.条件判空
        if (condition == null)
            throw new QCPromptException("条件不能为空");
        if (StringUtils.isBlank(condition.getOrgcode()))
            throw new QCPromptException("组织代码不能为空");

        //2.构造查询条件
        LambdaQueryWrapper<EhsUnitInfo> wrapper = new LambdaQueryWrapper<>();
        //组织代码
        wrapper.eq(EhsUnitInfo::getOrgcode, condition.getOrgcode());
        //查询时不根据条件中的是否在建、上级单元ID、关键字、状态进行过滤；因为可能查询结果中的父级和子级的属性数据不一致；在查询时先将组织中的所有单元查询出来，再最终返回结果中按照查询条件中的过滤条件进行过滤；

        //3.查询数据
        List<EhsUnitInfo> ens = repository.selectList(wrapper);
        if (CollectionUtils.isEmpty(ens)) return null;

        //4.转化为dtos
        List<EhsUnitDto> dtos = EhsUnitInfoMapper.MAPPER.toDtoList(ens);

        List<EhsUnitDto> result = new ArrayList<>();

        //5.从dtos中筛选符合查询条件的数据
        //判断查询条件中是否指定了父节点，如果指定了父节点获取父节点开始遍历子级；如果没有指定父节点优先获取根节点单元集合，再遍历根节点单元获取子级
        List<EhsUnitDto> rootUnits = new ArrayList<>();
        if (StringUtils.isNotBlank(condition.getParentid())) {
            rootUnits = dtos.stream().
                    filter(p -> p.getUnitid().equals(condition.getParentid())).collect(Collectors.toList());
        } else {
            rootUnits = dtos.stream().
                    filter(p -> StringUtils.isEmpty(p.getParentid())).collect(Collectors.toList());
        }
        if (CollectionUtils.isNotEmpty(rootUnits)) {
            for (EhsUnitDto rootUnit : rootUnits) {
                //是否返回当前单元，需要根据部门权限、状态、关键字等进行过滤后确定是否返回
                boolean notReturnUnit = false;
                //是否为在建工程：为0表示false，为1表示true，为空或其他时表示不管该标记状态
                if (StringUtils.isNotBlank(condition.getIsconstruction())) {
                    if (condition.getIsconstruction().equals("0")) {
                        if (rootUnit.isIsconstruction() == true) notReturnUnit = true;
                    } else if (condition.getIsconstruction().equals("1")) {
                        if (rootUnit.isIsconstruction() == false) notReturnUnit = true;
                    }
                }
                //是否根据用户部门进行过滤:为true表示根据当前用户所关联部门对单元进行筛选过滤，为false表示不过滤
                if (notReturnUnit == false && condition.isIsdept() == true) {
                    if (CollectionUtils.isNotEmpty(deptIds)) {
                        boolean deptIsExist = false;//level4的部门是否匹配用户部门
                        for (Integer deptId : deptIds) {
                            if (deptId == rootUnit.getResdeptid()) {
                                deptIsExist = true;
                            }
                        }
                        if (!deptIsExist) notReturnUnit = true;
                    }
                }
                //关键子匹配
                if (notReturnUnit == false && StringUtils.isNotBlank(condition.getKeywords())) {
                    if (!(rootUnit.getUnitid().contains(condition.getKeywords())) &&
                            !(rootUnit.getUnitname().contains(condition.getKeywords()))
                    ) {
                        notReturnUnit = true;
                    }
                }
                //是否只返回状态正常的记录
                if (notReturnUnit == false && condition.isFlagisvalid() == true) {
                    if (rootUnit.getFlag() != ResourceStatusFlagEnum.NORMAL.getIndex()) notReturnUnit = true;
                }

                if (notReturnUnit == false) {
                    result.add(rootUnit);
                    //判断是否需要获取根节点下的子级，如果为包含子级不再对子级根据部门权限、关键字过滤（因为父级单元已经进行过滤）
                    if (condition.isIncludechilds() == true) {
                        getChildUnitsList(result, condition, rootUnit, dtos);
                    }
                }
            }
        }

        return result;
    }

    /**
     * 递归获取下一级单元集合
     *
     * @param result     最终返回的单元List集合
     * @param condition  查询条件，需要根据其中的是否为在建工程和单元状态进行过滤
     * @param parentUnit 父级单元
     * @param allUnits   所有单元集合
     * @return void
     * @author QuCheng Tech
     * @since 2025/5/23
     */
    void getChildUnitsList(List<EhsUnitDto> result, EhsUnitQueryConditionDto condition, EhsUnitDto parentUnit, List<EhsUnitDto> allUnits) {
        if (parentUnit != null && allUnits != null && allUnits.size() > 0x0 && condition != null && condition.isIncludechilds() == true) {
            //根据父级单元获取下一级单元集合
            List<EhsUnitDto> childUnits = allUnits.stream().filter(p -> p.getParentid() != null &&
                    p.getParentid().equals(parentUnit.getUnitid())).collect(Collectors.toList());
            if (childUnits != null && childUnits.size() > 0x0) {
                for (EhsUnitDto unit : childUnits) {
                    //判断条件中的是否在建、状态
                    boolean notReturnUnit = false;
                    //是否为在建工程：为0表示false，为1表示true，为空或其他时表示不管该标记状态
                    if (StringUtils.isNotBlank(condition.getIsconstruction())) {
                        if (condition.getIsconstruction().equals("0")) {
                            if (unit.isIsconstruction() == true) notReturnUnit = true;
                        } else if (condition.getIsconstruction().equals("1")) {
                            if (unit.isIsconstruction() == false) notReturnUnit = true;
                        }
                    }
                    //是否只返回状态正常的记录
                    if (notReturnUnit == false && condition.isFlagisvalid() == true) {
                        if (unit.getFlag() != ResourceStatusFlagEnum.NORMAL.getIndex()) notReturnUnit = true;
                    }
                    if (notReturnUnit == false)
                        result.add(unit);

                    //获取单元的下级单元集合；返回结果为List不存在上下级关系，不管上级单元是否返回仍需要继续获取下级单元集合
                    getChildUnitsList(result, condition, unit, allUnits);
                }
            }
        }
    }

    /**
     * 获取指定
     *
     * @param id 单元代码
     * @return EhsUnitDto
     * @author QuCheng Tech
     * @since 2024/5/22
     */
    public EhsUnitDto get(String id) throws QCPromptException {
        if (StringUtils.isBlank(id)) throw new QCPromptException("单元代码不能为空");

        EhsUnitInfo en = repository.selectById(id);
        if (Objects.nonNull(en)) {
            return EhsUnitInfoMapper.MAPPER.toDto(en);
        }
        return null;
    }

    /***
     * 获取指定ID的单元Entity
     *
     * @param unitId 单元ID
     * @return qc.module.ehs.entity.EhsUnitInfo
     * @author QuCheng Tech
     * @since 2025/2/28
     */
    public EhsUnitInfo getEntity(String unitId) {
        if (StringUtils.isNotBlank(unitId))
            return repository.selectById(unitId);

        return null;
    }

    /**
     * 新增
     *
     * @param dto 单元信息
     * @return 成功返回null，失败返回错误或提示信息
     * @author QuCheng Tech
     * @update 2024/8/15 增加单元层级编码的处理
     * @since 2024/5/22
     */
    public String add(EhsUnitDto dto) {
        //1.单元信息判空
        if (dto == null)
            return QCUnifyReturnValue.Warn("单元信息不能为空");
        if (StringUtils.isBlank(dto.getOrgcode()))
            return QCUnifyReturnValue.Warn("组织代码不能为空");
        if (StringUtils.isBlank(dto.getUnitname()))
            return QCUnifyReturnValue.Warn("单元名称不能为空");
        if (StringUtils.isBlank(dto.getUccd()))
            return QCUnifyReturnValue.Warn("所属单元分类不能为空");

        //2.判断组织编码是否存在，不存在则提示
        EhsOrg ehsOrg = orgRepository.selectById(dto.getOrgcode());
        if (Objects.isNull(ehsOrg))
            return QCUnifyReturnValue.Warn("组织编码不存在");

        //3.判断所属单元分类是否存在，不存在则提示
        EhsTplUnitcategory unitcategory = unitcategoryRepository.selectById(dto.getUccd());
        if (Objects.isNull(unitcategory))
            return QCUnifyReturnValue.Warn("所属单元分类不存在");

        //4.将单元的是否为在建工程设置为单元分类的是否为在建工程的值
        dto.setIsconstruction(unitcategory.getIsconstruction());

        //5.如果有上级单元编码，判断上级单元编码是否存在，不存在则提示
        //处理设置单元层级编码：每个层级使用三位数表示，第一位表示所处层级，从1开始；每个层级编码为父层级编码+层级编码
        if (StringUtils.isNotBlank(dto.getParentid())) {
            EhsUnitInfo parentUnit = repository.selectById(dto.getParentid());
            if (Objects.isNull(parentUnit))
                return QCUnifyReturnValue.Warn("上级单元ID不存在");

            // 如果上级单元编码不为空，查询上级单元编码的子单元中最大层级编码，设置新增单元的层级编码+1。无数据时设置为父层级的第一个子级编码
            LambdaQueryWrapper<EhsUnitInfo> wrapper = new LambdaQueryWrapper<>();
            wrapper.eq(EhsUnitInfo::getParentid, dto.getParentid());
            wrapper.orderByDesc(EhsUnitInfo::getLevelcode);
            wrapper.last("limit 1");
            EhsUnitInfo unit = repository.selectOne(wrapper);
            if (Objects.nonNull(unit)) {
                //已有子级单元的情况
                //截取当前层级已有的最大层级编码
                String maxLevelCode = unit.getLevelcode().substring(unit.getLevelcode().length() - 3);
                //设置当前层级编码 = 最大层级编码+1
                String currentLevelCode = parentUnit.getLevelcode() + (Integer.parseInt(maxLevelCode) + 0x1);
                dto.setLevelcode(currentLevelCode);
            } else {
                //无子级单元的情况
                //判断父级单元是处于第几层级，每个层级三位数，第一位数表示所处层级
                //截取父层级的三位编码：层级编码最后三位
                String parentLevelCode = parentUnit.getLevelcode().substring(parentUnit.getLevelcode().length() - 3);
                //获取父层级编码第一位编码为父级所处层级
                String parentLevel = parentLevelCode.substring(0, 1);
                //处理设置当前层级编码：当前所处层级为父级所处层级+1，然后组成当前层级编码
                String currentLevelCode = Integer.parseInt(parentLevel) + 0x1 + "01";
                dto.setLevelcode(parentUnit.getLevelcode() + currentLevelCode);
            }
        } else {
            //如果上级单元编码为空，查询根层级的最大层级编码，设置新增单元的层级编码+1；无数据时设置层级编码为101
            LambdaQueryWrapper<EhsUnitInfo> wrapper = new LambdaQueryWrapper<>();
            wrapper.isNull(EhsUnitInfo::getParentid).or().eq(EhsUnitInfo::getParentid, dto.getParentid())
                    .orderByDesc(EhsUnitInfo::getLevelcode).last("limit 1");
            EhsUnitInfo unit = repository.selectOne(wrapper);
            if (Objects.nonNull(unit)) {
                Integer levelCode = Integer.parseInt(unit.getLevelcode()) + 0x1;
                dto.setLevelcode(String.valueOf(levelCode));
            } else {
                dto.setLevelcode("101");
            }
        }

        //6.dto -> entity
        EhsUnitInfo en = EhsUnitInfoMapper.MAPPER.dtoToEntity(dto);

        //7.设置单元ID
        en.setUnitid(IdentifierUtil.randomUUID());

        //8.保存数据
        if (repository.insert(en) < 0x1)
            return QCUnifyReturnValue.Warn("保存失败");
        return QCUnifyReturnValue.Success();
    }

    /**
     * 修改 修改时不对单元的责任机制信息（包括责任部门、责任人、安全员）进行设置，赋值传入也无效；
     *
     * @param dto 单元信息
     * @return 成功返回null，失败返回错误或提示信息
     * @author QuCheng Tech
     * @update 2024/8/15 增加单元层级编码的处理
     * @since 2024/5/23
     */
    public String update(EhsUnitDto dto) {
        //1.单元信息判空
        if (dto == null)
            return QCUnifyReturnValue.Warn("单元信息不能为空");
        if (StringUtils.isBlank(dto.getOrgcode()))
            return QCUnifyReturnValue.Warn("组织代码不能为空");
        if (StringUtils.isBlank(dto.getUnitid()))
            return QCUnifyReturnValue.Warn("单元ID不能为空");
        if (StringUtils.isBlank(dto.getUnitname()))
            return QCUnifyReturnValue.Warn("单元名称不能为空");
        if (StringUtils.isBlank(dto.getUccd()))
            return QCUnifyReturnValue.Warn("所属单元分类不能为空");

        //2.判断单元ID是否存在，不存在则提示
        EhsUnitInfo existUnitEntity = getEntity(dto.getUnitid());
        if (existUnitEntity == null)
            return QCUnifyReturnValue.Warn("指定的单元信息不存在");

        //3.判断组织编码是否存在，不存在则提示
        EhsOrg ehsOrg = orgRepository.selectById(dto.getOrgcode());
        if (Objects.isNull(ehsOrg))
            return QCUnifyReturnValue.Warn("组织编码不存在");

        //4.判断所属单元分类是否存在，不存在则提示
        EhsTplUnitcategory unitcategory = unitcategoryRepository.selectById(dto.getUccd());
        if (Objects.isNull(unitcategory))
            return QCUnifyReturnValue.Warn("所属单元分类不存在");

        //将单元的是否为在建工程设置为单元分类的是否为在建工程的值
        dto.setIsconstruction(unitcategory.getIsconstruction());

        //5.如果有上级单元编码，判断上级单元编码是否存在，不存在则提示
        //设置层级编码
        if (StringUtils.isNotBlank(dto.getParentid())) {
            //if (!isExist(dto.getParentid())) return QCUnifyReturnValue.Warn("上级单元ID不存在");
            EhsUnitInfo parentUnit = repository.selectById(dto.getParentid());
            if (Objects.isNull(parentUnit))
                return QCUnifyReturnValue.Warn("上级单元ID不存在");
            //修改父级为某个单元时：某个单元下已有子级单元情况、无子级单元情况处理
            //修改当前单元层级编码
            //判断当前单元修改后的父级单元是否有子级单元
            LambdaQueryWrapper<EhsUnitInfo> wrapper = new LambdaQueryWrapper<>();
            wrapper.eq(EhsUnitInfo::getParentid, dto.getParentid());
            wrapper.orderByDesc(EhsUnitInfo::getLevelcode);
            wrapper.last("limit 1");
            EhsUnitInfo unit = repository.selectOne(wrapper);
            if (Objects.nonNull(unit)) {
                //已有子级单元的情况
                //截取当前层级已有的最大层级编码
                String maxLevelCode = unit.getLevelcode().substring(unit.getLevelcode().length() - 3);
                ////设置当前层级编码 = 最大层级编码+1
                String currentLevelCode = parentUnit.getLevelcode() + (Integer.parseInt(maxLevelCode) + 0x1);
                dto.setLevelcode(currentLevelCode);

                //查询修改单元的子级单元，修改子级单元的层级编码
                updateSubLevelCode(dto.getUnitid(), dto.getLevelcode());
            } else {
                //无子级单元的情况
                //判断父级单元是处于第几层级，每个层级三位数，第一位数表示所处层级
                //截取父层级的三位编码：层级编码最后三位
                String parentLevelCode = parentUnit.getLevelcode().substring(parentUnit.getLevelcode().length() - 3);
                ////获取父层级编码第一位编码为父级所处层级
                String parentLevel = parentLevelCode.substring(0, 1);
                ////处理设置当前层级编码：当前所处层级为父级所处层级+1，然后组成当前层级编码
                String currentLevelCode = Integer.parseInt(parentLevel) + 0x1 + "01";
                dto.setLevelcode(parentUnit.getLevelcode() + currentLevelCode);

                //查询修改单元的子级单元，修改子级单元的层级编码
                updateSubLevelCode(dto.getUnitid(), dto.getLevelcode());
            }
        } else {
            //修改为根层级单元：当前单元修改前如果有子级，一并修改子级的层级编码
            //查询根层级的最大层级编码,设置当前单元修改后的层级编码；
            LambdaQueryWrapper<EhsUnitInfo> wrapper = new LambdaQueryWrapper<>();
            wrapper.isNull(EhsUnitInfo::getParentid).or().eq(EhsUnitInfo::getParentid, dto.getParentid())
                    .orderByDesc(EhsUnitInfo::getLevelcode).last("limit 1");
            EhsUnitInfo unit = repository.selectOne(wrapper);
            if (Objects.nonNull(unit)) {
                Integer levelCode = Integer.parseInt(unit.getLevelcode()) + 0x1;
                dto.setLevelcode(String.valueOf(levelCode));

                //查询修改单元的子级单元，修改子级单元的层级编码
                updateSubLevelCode(dto.getUnitid(), dto.getLevelcode());
            } else {
                dto.setLevelcode("101");
            }
        }

        //修改时不对责任机制信息进行修改，因此在此将已有的责任机制信息赋给更新的对象
        //单元中的危险源和隐患统计数量信息也不需要更新
        //修改为只更新部分属性，不使用实体更新方法
        //6.dto -> entity
        //EhsUnitInfo en = EhsUnitInfoMapper.MAPPER.dtoToEntity(dto);
        //7.更新数据
        //repository.updateById(en);
        LambdaUpdateWrapper<EhsUnitInfo> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper.eq(EhsUnitInfo::getUnitid, dto.getUnitid());

        updateWrapper.set(EhsUnitInfo::getUnitname, dto.getUnitname())
                .set(EhsUnitInfo::getParentid, dto.getParentid())
                .set(EhsUnitInfo::getLevelcode, dto.getLevelcode())
                .set(EhsUnitInfo::getIsconstruction, dto.isIsconstruction())
                .set(EhsUnitInfo::getUccd, dto.getUccd())
                .set(EhsUnitInfo::getLongitude, dto.getLongitude())
                .set(EhsUnitInfo::getLatitude, dto.getLatitude())
                .set(EhsUnitInfo::getLocation, dto.getLocation())
                .set(EhsUnitInfo::getIntroduction, dto.getIntroduction())
                .set(EhsUnitInfo::getBgimg, dto.getBgimg())
                .set(EhsUnitInfo::getOdr, dto.getOdr());

        repository.update(null, updateWrapper);

        return QCUnifyReturnValue.Success();
    }

    /**
     * 递归修改子级单元的层级编码
     *
     * @param parentUnitId    父层级单元ID
     * @param parentLevelCode 父层级单元的层级编码
     * @author QuCheng Tech
     * @since 2024/8/16
     */
    private void updateSubLevelCode(String parentUnitId, String parentLevelCode) {
        //查询修改单元的子级单元，修改子级单元的层级编码
        LambdaQueryWrapper<EhsUnitInfo> subWrapper = new LambdaQueryWrapper<>();
        subWrapper.eq(EhsUnitInfo::getParentid, parentUnitId)
                .orderByAsc(EhsUnitInfo::getLevelcode);
        List<EhsUnitInfo> subUnits = repository.selectList(subWrapper);
        if (CollectionUtils.isNotEmpty(subUnits)) {
            String subParentLevelCode = parentLevelCode.substring(parentLevelCode.length() - 3);
            String parentLevel = subParentLevelCode.substring(0, 1);
            int subLevelCode = Integer.parseInt(Integer.parseInt(parentLevel) + 0x1 + "00");
            for (EhsUnitInfo subUnit : subUnits) {
                subLevelCode++;
                subUnit.setLevelcode(parentLevelCode + subLevelCode);
                repository.updateById(subUnit);

                //查询修改单元的子级单元，修改子级单元的层级编码
                updateSubLevelCode(subUnit.getUnitid(), subUnit.getLevelcode());
            }
        }
    }

    /**
     * 删除 - 同时支持@RequestParam和@PathVariable方式
     *
     * @param id 单元编码
     * @return 成功返回null，失败返回错误或提示信息
     * @author QuCheng Tech
     * @since 2024/5/23
     */
    public String delete(String id) throws QCPromptException {
        if (StringUtils.isBlank(id)) return QCUnifyReturnValue.Warn("单元ID不能为空");

        //判断单元下是否有子级单元，有则不允许删除
        LambdaQueryWrapper<EhsUnitInfo> wrapper = new LambdaQueryWrapper<>();
        wrapper.select(EhsUnitInfo::getUnitid);
        wrapper.eq(EhsUnitInfo::getParentid, id);
        List<EhsUnitInfo> ens = repository.selectList(wrapper);
        if (CollectionUtils.isNotEmpty(ens)) return QCUnifyReturnValue.Warn("该单元下有子级单元，请先删除子级单元信息");

        //同步删除该单元下的静态信息
        LambdaQueryWrapper<EhsUnitStaticinfo> staticinfoWrapper = new LambdaQueryWrapper<>();
        staticinfoWrapper.eq(EhsUnitStaticinfo::getUnitid, id);
        List<EhsUnitStaticinfo> unitStaticInfos = unitStaticInfoRepository.selectList(staticinfoWrapper);
        if (CollectionUtils.isNotEmpty(unitStaticInfos)) {
            List<String> unitStaticInfoIds = unitStaticInfos.stream().map(EhsUnitStaticinfo::getId).collect(Collectors.toList());
            unitStaticInfoRepository.deleteBatchIds(unitStaticInfoIds);
        }

        repository.deleteById(id);
        return QCUnifyReturnValue.Success();
    }

    /**
     * 设置单元责任制
     *
     * @param dto 设置DTO
     * @return 成功返回null，失败返回错误或提示信息
     * @author QuCheng Tech
     * @since 2024/11/4
     */
    public String setUnitResponsibility(UnitResponsibilitySetDto dto) {
        if (dto == null) return QCUnifyReturnValue.Warn("设置DTO不能为空");
        if (CollectionUtils.isEmpty(dto.getUnitids())) return QCUnifyReturnValue.Warn("单元ID集合不能为空");

        LambdaUpdateWrapper<EhsUnitInfo> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper.in(EhsUnitInfo::getUnitid, dto.getUnitids());
        updateWrapper.set(EhsUnitInfo::getResdeptid, dto.getResdeptid())
                .set(EhsUnitInfo::getResdeptname, dto.getResdeptname())
                .set(EhsUnitInfo::getResuserid, dto.getResuserid())
                .set(EhsUnitInfo::getResusername, dto.getResusername())
                .set(EhsUnitInfo::getResuserphone, dto.getResuserphone())
                .set(EhsUnitInfo::getSafeuserid, dto.getSafeuserid())
                .set(EhsUnitInfo::getSafeusername, dto.getSafeusername())
                .set(EhsUnitInfo::getSafeuserphone, dto.getSafeuserphone());

        repository.update(null, updateWrapper);

        return QCUnifyReturnValue.Success();
    }

    /**
     * 判断单元代码是否存在
     *
     * @param id 单元代码
     * @return 存在返回true，否则返回false
     * @author QuCheng Tech
     * @since 2024/5/23
     */
    public boolean isExist(String id) {
        EhsUnitInfo en = repository.selectById(id);
        if (Objects.nonNull(en)) {
            return true;
        }
        return false;
    }

    /**
     * 根据指定组织代码查询单元信息
     *
     * @param orgCode 组织代码
     * @return List<EhsUnitDto>
     * @author QuCheng Tech
     * @since 2024/5/22
     */
    public List<EhsUnitDto> getUnitByOrgCode(String orgCode) {
        LambdaQueryWrapper<EhsUnitInfo> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(EhsUnitInfo::getOrgcode, orgCode);

        List<EhsUnitInfo> ens = repository.selectList(wrapper);
        if (CollectionUtils.isNotEmpty(ens)) {
            return EhsUnitInfoMapper.MAPPER.toDtoList(ens);
        }
        return null;
    }

    /**
     * 根据指定单元分类代码查询单元信息
     *
     * @param uccd 单元分类代码
     * @return List<EhsUnitDto>
     * @author QuCheng Tech
     * @since 2024/5/22
     */
    public List<EhsUnitDto> getUnitByCategoryCode(String uccd) {
        LambdaQueryWrapper<EhsUnitInfo> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(EhsUnitInfo::getUccd, uccd);

        //排序：先按排序号、再按名称
        wrapper.orderByAsc(EhsUnitInfo::getOdr).orderByAsc(EhsUnitInfo::getUnitname);

        List<EhsUnitInfo> ens = repository.selectList(wrapper);
        if (CollectionUtils.isNotEmpty(ens)) {
            return EhsUnitInfoMapper.MAPPER.toDtoList(ens);
        }
        return null;
    }

    /**
     * 获取指定单元ID集合的单元信息
     *
     * @param ids 单元ID集合
     * @return List<EhsUnitDto>
     * @author QuCheng Tech
     * @since 2024/11/19
     */
    public List<EhsUnitDto> getUnitsByIds(List<String> ids) {

        List<EhsUnitInfo> ens = repository.selectBatchIds(ids);
        if (CollectionUtils.isNotEmpty(ens)) {
            return EhsUnitInfoMapper.MAPPER.toDtoList(ens);
        }
        return null;
    }

    /**
     * 递归向上查找修改指定单元的父级单元信息数量统计
     * 查找当前单元的父级单元，直到根节点单元为止，每一层级的上级单元都要更新数量（每一层级单元数量统计只需要统计直接子级的数量即可）
     *
     * @param unitInfo 当前层级的单元信息
     * @author QuCheng Tech
     * @since 2024/8/23
     */
    public void modifyParentUnit(EhsUnitInfo unitInfo) throws QCPromptException {
        if (StringUtils.isNotBlank(unitInfo.getParentid())) {
            //查询当前用户组织的所有单元
            LambdaQueryWrapper<EhsUnitInfo> unitWrapper = new LambdaQueryWrapper<>();
            unitWrapper.eq(EhsUnitInfo::getOrgcode, unitInfo.getOrgcode());
            List<EhsUnitInfo> allUnits = repository.selectList(unitWrapper);
            //从allUnits找出当前单元的上级单元
            EhsUnitInfo parentUnit = allUnits.stream().filter(p -> p.getUnitid().equals(unitInfo.getParentid())).findAny().get();
            //找到上级单元的直接子级单元集合,统计所有子级单元各类/各风险等级数量(注意还要统计上父单元自己的数量)，修改上级单元信息
            List<EhsUnitInfo> pUnitChildren = allUnits.stream().filter(p -> StringUtils.isNotBlank(p.getParentid()) &&
                    p.getParentid().equals(parentUnit.getUnitid())).collect(Collectors.toList());
            if (CollectionUtils.isNotEmpty(pUnitChildren)) {
                int general1 = 0x0, major1 = 0x0, level11 = 0x0, level12 = 0x0, level13 = 0x0, level14 = 0x0,
                        general2 = 0x0, major2 = 0x0, level21 = 0x0, level22 = 0x0, level23 = 0x0, level24 = 0x0;
                for (EhsUnitInfo pUnitChild : pUnitChildren) {
                    general1 += pUnitChild.getGeneral1() == null ? 0x0 : pUnitChild.getGeneral1();
                    major1 += pUnitChild.getMajor1() == null ? 0x0 : pUnitChild.getMajor1();
                    level11 += pUnitChild.getLevel11() == null ? 0x0 : pUnitChild.getLevel11();
                    level12 += pUnitChild.getLevel12() == null ? 0x0 : pUnitChild.getLevel12();
                    level13 += pUnitChild.getLevel13() == null ? 0x0 : pUnitChild.getLevel13();
                    level14 += pUnitChild.getLevel14() == null ? 0x0 : pUnitChild.getLevel14();
                    general2 += pUnitChild.getGeneral2() == null ? 0x0 : pUnitChild.getGeneral2();
                    major2 += pUnitChild.getMajor2() == null ? 0x0 : pUnitChild.getMajor2();
                    level21 += pUnitChild.getLevel21() == null ? 0x0 : pUnitChild.getLevel21();
                    level22 += pUnitChild.getLevel22() == null ? 0x0 : pUnitChild.getLevel22();
                    level23 += pUnitChild.getLevel23() == null ? 0x0 : pUnitChild.getLevel23();
                    level24 += pUnitChild.getLevel24() == null ? 0x0 : pUnitChild.getLevel24();
                }
                // 设置父单元各类/各风险等级的数量统计：如果父单元有辨识记录（辨识时间不为空），
                // 则父单元自己的数量 + 所有直接子级单元的数量，否则只统计直接自己的危险源数量之和
                if (parentUnit.getIdtm() == null) {
                    //父单元自己没有辨识记录时，统计数量 = 直接子级单元的危险源统计数量之和
                    parentUnit.setGeneral1(general1);
                    parentUnit.setMajor1(major1);
                    parentUnit.setLevel11(level11);
                    parentUnit.setLevel12(level12);
                    parentUnit.setLevel13(level13);
                    parentUnit.setLevel14(level14);
                    parentUnit.setGeneral2(general2);
                    parentUnit.setMajor2(major2);
                    parentUnit.setLevel21(level21);
                    parentUnit.setLevel22(level22);
                    parentUnit.setLevel23(level23);
                    parentUnit.setLevel24(level24);
                } else {
                    //父单元自己已有辨识记录时，统计数量 = 父单元的危险源统计数量 + 直接子级单元的危险源统计数量
                    //查询父单元的危险源信息，先统计出父单元自己的各类/各风险等级的危险源数量，再加上直接子级单元的各类/各风险等级的危险源数量之和
                    int pGeneral1 = 0x0, pMajor1 = 0x0, pLevel11 = 0x0, pLevel12 = 0x0, pLevel13 = 0x0, pLevel14 = 0x0,
                            pGeneral2 = 0x0, pMajor2 = 0x0, pLevel21 = 0x0, pLevel22 = 0x0, pLevel23 = 0x0, pLevel24 = 0x0;
                    List<String> unitids = new ArrayList<>();
                    unitids.add(parentUnit.getUnitid());
                    List<EhsHazardInfoDto> pUnitHazards = hazardInfoService.getHazardsByUnitIds(unitids);
                    if (CollectionUtils.isNotEmpty(pUnitHazards)) {
                        for (EhsHazardInfoDto hazardInfoDto : pUnitHazards) {
                            if (hazardInfoDto.getIdentificationresult() == EhsHazardIndentificationResultTypeEnum.HAZARD.getIndex()) {
                                //第一类危险源
                                if (hazardInfoDto.isIsmajor()) pMajor1 += 0x1;
                                else pGeneral1 += 0x1;
                                if (hazardInfoDto.getRisklevel() == EhsRiskLevelEnum.LOW.getIndex())
                                    pLevel11 += 0x1;
                                else if (hazardInfoDto.getRisklevel() == EhsRiskLevelEnum.GENERAL.getIndex())
                                    pLevel12 += 0x1;
                                else if (hazardInfoDto.getRisklevel() == EhsRiskLevelEnum.GREATER.getIndex())
                                    pLevel13 += 0x1;
                                else if (hazardInfoDto.getRisklevel() == EhsRiskLevelEnum.MAJOR.getIndex())
                                    pLevel14 += 0x1;
                            } else if (hazardInfoDto.getIdentificationresult() == EhsHazardIndentificationResultTypeEnum.HIDDEN_TROUBLE.getIndex()) {
                                //第二类危险源
                                if (hazardInfoDto.isIsmajor()) pMajor2 += 0x1;
                                else pGeneral2 += 0x1;
                                if (hazardInfoDto.getRisklevel() == EhsRiskLevelEnum.LOW.getIndex())
                                    pLevel21 += 0x1;
                                else if (hazardInfoDto.getRisklevel() == EhsRiskLevelEnum.GENERAL.getIndex())
                                    pLevel22 += 0x1;
                                else if (hazardInfoDto.getRisklevel() == EhsRiskLevelEnum.GREATER.getIndex())
                                    pLevel23 += 0x1;
                                else if (hazardInfoDto.getRisklevel() == EhsRiskLevelEnum.MAJOR.getIndex())
                                    pLevel24 += 0x1;
                            } else {
                                //不存在/不适用
                            }
                        }
                    }
                    parentUnit.setGeneral1(pGeneral1 + general1);
                    parentUnit.setMajor1(pMajor1 + major1);
                    parentUnit.setLevel11(pLevel11 + level11);
                    parentUnit.setLevel12(pLevel12 + level12);
                    parentUnit.setLevel13(pLevel13 + level13);
                    parentUnit.setLevel14(pLevel14 + level14);
                    parentUnit.setGeneral2(pGeneral2 + general2);
                    parentUnit.setMajor2(pMajor2 + major2);
                    parentUnit.setLevel21(pLevel21 + level21);
                    parentUnit.setLevel22(pLevel22 + level22);
                    parentUnit.setLevel23(pLevel23 + level23);
                    parentUnit.setLevel24(pLevel24 + level24);
                }
                repository.updateById(parentUnit);
            }

            if (StringUtils.isNotBlank(parentUnit.getParentid())) {
                modifyParentUnit(parentUnit);
            }
        }
    }

    /**
     * 获取指定单元分类代码的单元简要信息
     *
     * @param orgCode 组织代码
     * @param uccd 单元分类代码
     * @return java.util.List<qc.module.ehs.dto.unit.EhsUnitSimpleDto>
     * @author QuCheng Tech
     * @since 2025/1/15
     */
    public List<EhsUnitSimpleDto> getUnitSimpleByCategoryCode(String orgCode, String uccd) {
        LambdaQueryWrapper<EhsUnitInfo> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(EhsUnitInfo::getOrgcode, orgCode);
        wrapper.eq(EhsUnitInfo::getUccd, uccd);

        //排序：先按排序号、再按名称
        wrapper.orderByAsc(EhsUnitInfo::getOdr).orderByAsc(EhsUnitInfo::getUnitname);

        List<EhsUnitInfo> ens = repository.selectList(wrapper);
        if (CollectionUtils.isNotEmpty(ens)) {
            return EhsUnitInfoMapper.MAPPER.toDtoSimpleList(ens);
        }

        return null;
    }
}
